Batchvorhersagenvon einem benutzerdefinierten trainierten Modell abrufen

Auf dieser Seite erfahren Sie, wie Sie mithilfe der Google Cloud Console oder der Vertex AI API Batchvorhersagen aus Ihren benutzerdefiniert trainierten Modellen abrufen.

Für eine Batchvorhersage geben Sie eine Eingabequelle und einen Ausgabespeicherort an, entweder Cloud Storage oder BigQuery, wobei Vertex AI die Ergebnisse der Batchvorhersage speichert.

Beschränkungen und Anforderungen

Beachten Sie die folgenden Einschränkungen und Anforderungen, wenn Sie Batch-Vorhersagen abrufen:

• Damit die Verarbeitungszeit möglichst gering ist, müssen sich die Ein- und Ausgabestandorte in derselben Region oder Multiregion befinden. Wenn Ihre Eingabe beispielsweise in us-central1 liegt, kann die Ausgabe in us-central1 oder US liegen, aber nicht in europe-west4. Weitere Informationen finden Sie unter Cloud Storage-Standorte und BigQuery-Standorte.
• Ihre Eingabe und Ausgabe müssen sich außerdem in derselben Region oder Mehrfachregion befinden wie Ihr Modell.
• Model Garden-Modelle werden nicht unterstützt.
• BigQuery ML-Modelle sind keine benutzerdefinierten trainierten Modelle. Die Informationen auf dieser Seite können jedoch verwendet werden, um unter den folgenden Bedingungen Batchvorhersagen aus einem BigQuery ML-Modell zu erhalten:
  • Das BigQuery ML-Modell muss in Vertex AI Model Registry registriert sein.
  • Wenn Sie eine BigQuery-Tabelle als Eingabe verwenden möchten, müssen Sie InstanceConfig.instanceType mit der Vertex AI API auf "object" festlegen.

Anforderungen an Eingabedaten

Die Eingabe für Batchanfragen gibt die Elemente an, die zur Vorhersage an Ihr Modell gesendet werden sollen. Wir unterstützen die folgenden Eingabeformate:

[1, 2, 3, 4]
[5, 6, 7, 8]

{"instances": [ [1, 2, 3, 4], [5, 6, 7, 8] ]}

{"instances": [
{ "data": [1, 2, 3, 4] },
{ "data": [5, 6, 7, 8] } ]}

{ "values": [1, 2, 3, 4], "key": 1 }
{ "values": [5, 6, 7, 8], "key": 2 }

{"instances": [
  { "values": [1, 2, 3, 4], "key": 1 },
  { "values": [5, 6, 7, 8], "key": 2 }
]}

{ "data": { "values": [1, 2, 3, 4], "key": 1 } }
{ "data": { "values": [5, 6, 7, 8], "key": 2 } }

{"instances": [
  { "data": { "values": [1, 2, 3, 4], "key": 1 } },
  { "data": { "values": [5, 6, 7, 8], "key": 2 } }
]}

{"instances": [
{ "b64": "b64EncodedASCIIString" },
{ "b64": "b64EncodedASCIIString" } ]}

{"instances": [ { "data": {"b64": "b64EncodedASCIIString" } }, { "data": {"b64": "b64EncodedASCIIString" } }
]}

"input1","input2","input3"
0.1,1.2,"cat1"
4.0,5.0,"cat2"

{"instances": [ [0.1,1.2,"cat1"], [4.0,5.0,"cat2"] ]}

{"instances": [
{ "data": [0.1,1.2,"cat1"] },
{ "data": [4.0,5.0,"cat2"] } ]}

gs://path/to/image/image1.jpg
gs://path/to/image/image2.jpg

{ "instances": [
{ "b64": "b64EncodedASCIIString" },
{ "b64": "b64EncodedASCIIString" } ]}

{ "instances": [ { "data": { "b64": "b64EncodedASCIIString" } }, { "data": { "b64": "b64EncodedASCIIString" } }
]}

{"instances": [ [1.0,3.0,"cat1"], [2.0,4.0,"cat2"] ]}

{"instances": [
{ "data": [1.0,3.0,"cat1"] },
{ "data": [2.0,4.0,"cat2"] } ]}

Partitionsdaten

Die Batchvorhersage verwendet MapReduce, um die Eingabe auf jedes Replikat zu fragmentieren. Damit Sie die MapReduce-Funktionen nutzen können, muss die Eingabe partitionierbar sein.

Vertex AI partitioniert automatisch die BigQuery-, Dateilisten- und JSON Lines-Eingaben.

Vertex AI partitioniert CSV-Dateien nicht automatisch, da sie nicht von Natur aus partitionierbar sind. Zeilen in CSV-Dateien sind weder selbstbeschreibend noch typisiert und können Zeilenumbrüche enthalten. Wir empfehlen, für leistungsintensive Anwendungen keine CSV-Eingabe zu verwenden.

Partitionieren Sie bei der TFRecord-Eingabe die Daten manuell. Teilen Sie dazu die Instanzen in kleinere Dateien auf und übergeben Sie die Dateien mit einem Platzhalter (z. B. gs://my-bucket/*.tfrecord) an den Job. Die Anzahl der Dateien sollte mindestens der angegebenen Anzahl an Replikaten entsprechen.

Eingabedaten filtern und transformieren

Um Ihre Batcheingabe zu filtern oder zu transformieren, können Sie instanceConfig in der BatchPredictionJob-Anfrage angeben.

Mit der Filterung können Sie entweder bestimmte Felder aus den Eingabedaten aus Ihrer Vorhersageanfrage ausschließen oder nur einen Teil der Felder aus den Eingabedaten in Ihrer Vorhersageanfrage einschließen, ohne dass benutzerdefinierte Vor-/Nachverarbeitung im Vorhersagecontainer ausführen. Dies ist nützlich, wenn die Eingabedatendatei zusätzliche Spalten enthält, die vom Modell nicht benötigt werden, z. B. Schlüssel oder zusätzliche Daten.

Mit der Transformation können Sie die Instanzen im JSON-Format array oder object an den Vorhersagecontainer senden. Weitere Informationen finden Sie unter instanceType.

Angenommen, Ihre Eingabetabelle enthält Folgendes:

und Sie geben die folgende instanceConfig an:

{
  "name": "batchJob1",
  ...
  "instanceConfig": {
    "excludedFields":["customerId"]
    "instanceType":"object"
  }
}

Anschließend werden die Instanzen in Ihrer Vorhersageanfrage als JSON-Objekte gesendet und die Spalte customerId wird ausgeschlossen:

{"col1":1,"col2":2}
{"col1":5,"col2":6}

Beachten Sie, dass bei Angabe des folgenden instanceConfig dasselbe Ergebnis zurückgegeben wird:

{
  "name": "batchJob1",
  ...
  "instanceConfig": {
    "includedFields": ["col1","col2"]
    "instanceType":"object"
  }
}

Eine Demonstration zur Verwendung von Featurefiltern finden Sie im Notebook Batchvorhersage mit einem benutzerdefiniertes Modell und mit Featurefilterung.

Eine Batchvorhersage anfordern

Für Batchvorhersageanfragen können Sie die Google Cloud Console oder die Vertex AI API verwenden. Abhängig von der Anzahl der Eingabeelemente, die Sie eingereicht haben, kann die Batchvorhersage eine Weile dauern.

Wenn Sie eine Batchvorhersage anfordern, wird der Vorhersagecontainer als vom Nutzer bereitgestelltes benutzerdefiniertes Dienstkonto ausgeführt. Die Lese-/Schreibvorgänge, z. B. das Lesen der Vorhersageinstanzen aus der Datenquelle oder das Schreiben der Vorhersageergebnisse, erfolgen standardmäßig mit dem Vertex AI-Dienst-Agent, der standardmäßig Zugriff auf BigQuery und Cloud Storage hat.

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

{
  "displayName": "BATCH_JOB_NAME",
  "model": "projects/PROJECT_ID/locations/LOCATION_ID/models/MODEL_ID",
  "inputConfig": {
    "instancesFormat": "INPUT_FORMAT",
    "gcsSource": {
      "uris": ["INPUT_URI"],
    },
  },
  "outputConfig": {
    "predictionsFormat": "jsonl",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_DIRECTORY",
    },
  },
  "dedicatedResources" : {
    "machineSpec" : {
      "machineType": MACHINE_TYPE
    },
    "startingReplicaCount": STARTING_REPLICA_COUNT
  },
  "manualBatchTuningParameters": {
    "batch_size": BATCH_SIZE,
  }
}

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/batchPredictionJobs"

$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/batchPredictionJobs" | Select-Object -Expand Content

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/batchPredictionJobs/BATCH_JOB_ID",
  "displayName": "BATCH_JOB_NAME 202005291958",
  "model": "projects/PROJECT_ID/locations/LOCATION_ID/models/MODEL_ID",
  "inputConfig": {
    "instancesFormat": "jsonl",
    "gcsSource": {
      "uris": [
        "INPUT_URI"
      ]
    }
  },
  "outputConfig": {
    "predictionsFormat": "jsonl",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_DIRECTORY"
    }
  },
  "state": "JOB_STATE_PENDING",
  "createTime": "2020-05-30T02:58:44.341643Z",
  "updateTime": "2020-05-30T02:58:44.341643Z",
}

import com.google.cloud.aiplatform.util.ValueConverter;
import com.google.cloud.aiplatform.v1.AcceleratorType;
import com.google.cloud.aiplatform.v1.BatchDedicatedResources;
import com.google.cloud.aiplatform.v1.BatchPredictionJob;
import com.google.cloud.aiplatform.v1.GcsDestination;
import com.google.cloud.aiplatform.v1.GcsSource;
import com.google.cloud.aiplatform.v1.JobServiceClient;
import com.google.cloud.aiplatform.v1.JobServiceSettings;
import com.google.cloud.aiplatform.v1.LocationName;
import com.google.cloud.aiplatform.v1.MachineSpec;
import com.google.cloud.aiplatform.v1.ModelName;
import com.google.protobuf.Value;
import java.io.IOException;

public class CreateBatchPredictionJobSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String displayName = "DISPLAY_NAME";
    String modelName = "MODEL_NAME";
    String instancesFormat = "INSTANCES_FORMAT";
    String gcsSourceUri = "GCS_SOURCE_URI";
    String predictionsFormat = "PREDICTIONS_FORMAT";
    String gcsDestinationOutputUriPrefix = "GCS_DESTINATION_OUTPUT_URI_PREFIX";
    createBatchPredictionJobSample(
        project,
        displayName,
        modelName,
        instancesFormat,
        gcsSourceUri,
        predictionsFormat,
        gcsDestinationOutputUriPrefix);
  }

  static void createBatchPredictionJobSample(
      String project,
      String displayName,
      String model,
      String instancesFormat,
      String gcsSourceUri,
      String predictionsFormat,
      String gcsDestinationOutputUriPrefix)
      throws IOException {
    JobServiceSettings settings =
        JobServiceSettings.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 (JobServiceClient client = JobServiceClient.create(settings)) {

      // Passing in an empty Value object for model parameters
      Value modelParameters = ValueConverter.EMPTY_VALUE;

      GcsSource gcsSource = GcsSource.newBuilder().addUris(gcsSourceUri).build();
      BatchPredictionJob.InputConfig inputConfig =
          BatchPredictionJob.InputConfig.newBuilder()
              .setInstancesFormat(instancesFormat)
              .setGcsSource(gcsSource)
              .build();
      GcsDestination gcsDestination =
          GcsDestination.newBuilder().setOutputUriPrefix(gcsDestinationOutputUriPrefix).build();
      BatchPredictionJob.OutputConfig outputConfig =
          BatchPredictionJob.OutputConfig.newBuilder()
              .setPredictionsFormat(predictionsFormat)
              .setGcsDestination(gcsDestination)
              .build();
      MachineSpec machineSpec =
          MachineSpec.newBuilder()
              .setMachineType("n1-standard-2")
              .setAcceleratorType(AcceleratorType.NVIDIA_TESLA_T4)
              .setAcceleratorCount(1)
              .build();
      BatchDedicatedResources dedicatedResources =
          BatchDedicatedResources.newBuilder()
              .setMachineSpec(machineSpec)
              .setStartingReplicaCount(1)
              .setMaxReplicaCount(1)
              .build();
      String modelName = ModelName.of(project, location, model).toString();
      BatchPredictionJob batchPredictionJob =
          BatchPredictionJob.newBuilder()
              .setDisplayName(displayName)
              .setModel(modelName)
              .setModelParameters(modelParameters)
              .setInputConfig(inputConfig)
              .setOutputConfig(outputConfig)
              .setDedicatedResources(dedicatedResources)
              .build();
      LocationName parent = LocationName.of(project, location);
      BatchPredictionJob response = client.createBatchPredictionJob(parent, batchPredictionJob);
      System.out.format("response: %s\n", response);
      System.out.format("\tName: %s\n", response.getName());
    }
  }
}

def create_batch_prediction_job_dedicated_resources_sample(
    project: str,
    location: str,
    model_resource_name: str,
    job_display_name: str,
    gcs_source: Union[str, Sequence[str]],
    gcs_destination: str,
    instances_format: str = "jsonl",
    machine_type: str = "n1-standard-2",
    accelerator_count: int = 1,
    accelerator_type: Union[str, aiplatform_v1.AcceleratorType] = "NVIDIA_TESLA_K80",
    starting_replica_count: int = 1,
    max_replica_count: int = 1,
    sync: bool = True,
):
    aiplatform.init(project=project, location=location)

    my_model = aiplatform.Model(model_resource_name)

    batch_prediction_job = my_model.batch_predict(
        job_display_name=job_display_name,
        gcs_source=gcs_source,
        gcs_destination_prefix=gcs_destination,
        instances_format=instances_format,
        machine_type=machine_type,
        accelerator_count=accelerator_count,
        accelerator_type=accelerator_type,
        starting_replica_count=starting_replica_count,
        max_replica_count=max_replica_count,
        sync=sync,
    )

    batch_prediction_job.wait()

    print(batch_prediction_job.display_name)
    print(batch_prediction_job.resource_name)
    print(batch_prediction_job.state)
    return batch_prediction_job

Maschinentyp und Anzahl der Replikate wählen

Durch horizontale Skalierung durch eine Steigerung der Anzahl der Replikate wird der Durchsatz linearer und vorhersehbarer verbessert als durch die Verwendung größerer Maschinentypen.

Im Allgemeinen empfehlen wir, den kleinstmöglichen Maschinentyp für Ihren Job anzugeben und die Anzahl der Replikate zu erhöhen.

Aus Gründen der Kosteneffizienz empfehlen wir, dass Sie die Replikatanzahl so auswählen, dass Ihr Batchvorhersagejob mindestens 10 Minuten lang ausgeführt wird. Der Grund ist, dass Ihnen Kosten pro Replikatknotenstunde in Rechnung gestellt werden, inklusive der etwa 5 Minuten, die jedes Replikat zum Start benötigt. Es ist nicht kostengünstig, nur wenige Sekunden Rechenarbeiten auszuführen und dann herunterzufahren.

Als allgemeine Orientierungshilfe empfehlen wir für Tausende von Instanzen einen starting_replica_count in mehreren Zehntausend. Bei Millionen von Instanzen empfehlen wir einen starting_replica_count im Bereich von mehreren Hunderten. Sie können auch die folgende Formel verwenden, um die Anzahl der Replikate zu schätzen:

N / (T * (60 / Tb))

Dabei gilt:

• N: Die Anzahl der Batches im Job. Beispiel: 1 Million Instanzen/Batchgröße von 100 = 10.000 Batches.
• T: Die voraussichtliche Zeit für den Batchvorhersagejob. Beispiel: 10 Minuten.
• Tb: Die Zeit in Sekunden, die ein Replikat benötigt, um einen einzelnen Batch zu verarbeiten. Beispiel: 1 Sekunde pro Batch bei einem Maschinentyp mit 2 Kernen.

In unserem Beispiel werden 10.000 Batches/(10 Minuten * (60/1 s)) auf 17 Replikate aufgerundet.

Im Gegensatz zur Onlinevorhersage werden Batchvorhersagejobs nicht automatisch skaliert. Da alle Eingabedaten vorab bekannt sind, partitioniert das System die Daten beim Start des Jobs auf jedes Replikat. Das System verwendet den Parameter starting_replica_count. Der Parameter max_replica_count wird ignoriert.

Diese Empfehlungen sind ungefähre Richtlinien. Sie bieten nicht unbedingt für jedes Modell einen optimalen Durchsatz. Sie liefern keine genauen Vorhersagen in Bezug auf Verarbeitungszeit und Kosten. Und sie bieten nicht unbedingt für jedes Szenario die besten Kompromisse in Bezug auf Kosten/Durchsatz. Verwenden Sie sie als guten Ausgangspunkt und passen Sie sie bei Bedarf an. Führen Sie zum Messen von Merkmalen wie dem Durchsatz für Ihr Modell das Notebook Idealen Maschinentyp ermitteln aus.

Für GPU- oder TPU-beschleunigte Maschinen

Beachten Sie die vorherigen Richtlinien (die auch für reine CPU-Modelle gelten) und beachten Sie folgende zusätzliche Überlegungen:

• Möglicherweise benötigen Sie mehr CPUs und GPUs (z. B. für die Datenvorverarbeitung).
• GPU-Maschinentypen benötigen mehr Zeit für den Start (10 Minuten). Daher sollten Sie für den Batchvorhersagejob längere Zeiten (z. B. mindestens 20 Minuten anstelle von 10 Minuten) einplanen, damit eine angemessener Menge Zeit und Kosten für die Generierung von Vorhersagen genutzt wird.

Batchvorhersageergebnisse abrufen

Wenn eine Batchvorhersage abgeschlossen ist, wird die Ausgabe der Vorhersage in dem Cloud Storage-Bucket oder BigQuery-Speicherort gespeichert, den Sie in Ihrer Anfrage angegeben haben.

Beispiel für ein Batchvorhersageergebnis

Der Ausgabeordner enthält eine Reihe von JSON-Lines-Dateien.

Die Dateien heißen {gcs_path}/prediction.results-{file_number}-of-{number_of_files_generated}. Die Anzahl der Dateien ist aufgrund der verteilten Natur von Batchvorhersagen nicht deterministisch.

Jede Zeile in der Datei entspricht einer Instanz aus der Eingabe und hat die folgenden Schlüssel/Wert-Paare:

• prediction: Enthält den vom Vorhersagecontainer zurückgegebenen Wert.
• instance: Enthält für Dateilisten den Cloud Storage-URI. Bei allen anderen Eingabeformaten enthält es den Wert, der an den Vorhersagecontainer im HTTP-Anfragetext gesendet wurde.

Beispiel 1

Wenn die HTTP-Anfrage Folgendes enthält:

{
  "instances": [
    [1, 2, 3, 4],
    [5, 6, 7, 8]
]}

Und der Vorhersagecontainer Folgendes zurückgibt:

{
  "predictions": [
    [0.1,0.9],
    [0.7,0.3]
  ],
}

Dann ist dies die JSON Lines-Ausgabedatei:

{ "instance": [1, 2, 3, 4], "prediction": [0.1,0.9]}
{ "instance": [5, 6, 7, 8], "prediction": [0.7,0.3]}

Beispiel 2

Wenn die HTTP-Anfrage Folgendes enthält:

{
  "instances": [
    {"values": [1, 2, 3, 4], "key": 1},
    {"values": [5, 6, 7, 8], "key": 2}
]}

Und der Vorhersagecontainer Folgendes zurückgibt:

{
  "predictions": [
    {"result":1},
    {"result":0}
  ],
}

Dann ist dies die JSON Lines-Ausgabedatei:

{ "instance": {"values": [1, 2, 3, 4], "key": 1}, "prediction": {"result":1}}
{ "instance": {"values": [5, 6, 7, 8], "key": 2}, "prediction": {"result":0}}

Explainable AI verwenden

Wir empfehlen nicht, merkmalsbasierte Erklärungen für eine große Datenmenge auszuführen. Das liegt daran, dass jede Eingabe je nach möglichen Feature-Werten potenziell in Tausende von Anfragen verzweigt werden kann, was zu einer deutlichen Erhöhung der Verarbeitungszeit und der Kosten führen kann. Im Allgemeinen reicht ein kleiner Datensatz aus, um die Bedeutung von Merkmalen zu verstehen.

Die Batch-Vorhersage unterstützt keine beispielbasierten Erklärungen.

Notebooks

Nächste Schritte

• Informationen zu Rechenressourcen für Vorhersagen