Batch-Inferenzen von einem benutzerdefinierten trainierten Modell abrufen

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

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

Beschränkungen und Anforderungen

Beachten Sie die folgenden Einschränkungen und Anforderungen, wenn Sie Batchvorhersagen 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.
• BigQuery ML-Modelle sind keine benutzerdefinierten trainierten Modelle. Die Informationen auf dieser Seite können jedoch verwendet werden, um Batchinferenzen aus einem BigQuery ML-Modell unter den folgenden Bedingungen abzurufen:
  • Das BigQuery ML-Modell muss bei 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.
• Das Laden eines Batchinferenzmodells dauert etwa 40 Minuten. Wenn die folgende Fehlermeldung angezeigt wird, verwenden Sie ein kleineres Modell für Batchvorhersagen: Error: model server never became ready. Please validate that your model file or container configuration are valid.

Anforderungen an Eingabedaten

Die Eingabe für Batchanfragen gibt die Elemente an, die zur Inferenz 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"] } ]}

Daten partitionieren

Die Batchinferenz verwendet MapReduce, um die Eingabe auf jedes Replikat zu fragmentieren. Damit die MapReduce-Funktionen genutzt werden 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 raten davon ab, CSV-Eingaben für durchsatzsensible Anwendungen 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 Inferenzanfrage ausschließen oder nur einen Teil der Felder aus den Eingabedaten in Ihrer Inferenzanfrage einschließen, ohne dass benutzerdefinierte Vor-/Nachverarbeitung im Inferenzcontainer 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 Container 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 Inferenzanfrage 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 Batchinferenz mit einem benutzerdefinierten Modell und mit Featurefilterung.

Batchinferenz anfordern

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

Wenn Sie eine Batchinferenz anfordern, wird der Inferenzcontainer als vom Nutzer bereitgestelltes benutzerdefiniertes Dienstkonto ausgeführt. Die Lese-/Schreibvorgänge, z. B. das Lesen der Inferenzinstanzen aus der Datenquelle oder das Schreiben der Inferenz-Ergebnisse, 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 Batchinferenzjob 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 in 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 erwartete Zeit für den Batchinferenzjob. 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.

Anders als bei der Onlineinferenz werden Batchinferenzjobs nicht automatisch skaliert. Da alle Eingabedaten im Voraus bekannt sind, partitioniert das System die Daten beim Start des Jobs in die einzelnen Replikate. Das System verwendet den Parameter starting_replica_count. Der Parameter max_replica_count wird ignoriert.

Diese Empfehlungen sind ungefähre Richtlinien. Es ist nicht sicher, dass sie für jedes Modell einen optimalen Durchsatz bieten. Sie liefern keine genauen Schätzungen 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 die folgenden zusätzlichen Ü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 Batchinferenzjob längere Zeiten (z. B. mindestens 20 Minuten anstelle von 10 Minuten) einplanen, damit ein angemessener Anteil der Zeit und Kosten für die Generierung von Inferenzen aufgewendet wird.

Batchinferenzergebnisse abrufen

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

Beispiel für ein Batchinferenzergebnis

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 Batchinferenz 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 Container 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 Container im HTTP-Anfragetext gesendet wurde.

Beispiel 1

Wenn die HTTP-Anfrage Folgendes enthält:

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

Der Container gibt Folgendes zurück:

{
  "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}
]}

Der Container gibt Folgendes zurück:

{
  "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, funktionsbasierten Erklärungen nicht für große Datenmengen zu verwenden. Das liegt daran, dass jede Eingabe potenziell zu Tausenden von Anfragen führen kann, basierend auf den möglichen Feature-Werten. Dies kann zu einer massiv erhöhten Verarbeitungszeit und ‑kosten führen. Im Allgemeinen reicht ein kleines Dataset aus, um die Merkmalwichtigkeit zu ermitteln.

Die Batchinferenz unterstützt keine beispielbasierten Erklärungen.

Notebooks

Nächste Schritte

• Informationen zu Rechenressourcen für Inferenz