Ottenere inferenze collettive da un modello con addestramento personalizzato

Questa pagina mostra come ottenere inferenze batch dai modelli addestrati personalizzati utilizzando la console Google Cloud o l'API Vertex AI.

Per effettuare una richiesta di inferenza batch, specifica un'origine di input e una posizione di output, Cloud Storage o BigQuery, in cui Vertex AI memorizza i risultati dell'inferenza batch.

Limitazioni e requisiti

Tieni presenti le seguenti limitazioni e requisiti quando ottieni inferenze batch:

• Per ridurre al minimo il tempo di elaborazione, le località di input e output devono trovarsi nella stessa regione o area multiregionale. Ad esempio, se l'input è in us-central1, l'output può essere in us-central1 o US, ma non in europe-west4. Per saperne di più, consulta Località di Cloud Storage e Località BigQuery.
• L'input e l'output devono trovarsi nella stessa regione o area multiregionale del modello.
• I modelli BigQuery ML non sono modelli addestrati personalizzati. Tuttavia, le informazioni in questa pagina possono essere utilizzate per ottenere inferenze batch da un modello BigQuery ML alle seguenti condizioni:
  • Il modello BigQuery ML deve essere registrato in Vertex AI Model Registry.
  • Per utilizzare una tabella BigQuery come input, devi impostare InstanceConfig.instanceType su "object" utilizzando l'API Vertex AI.
• Il caricamento di un modello di inferenza batch scade dopo circa 40 minuti. Se visualizzi il seguente messaggio di errore, utilizza un modello più piccolo per le inferenze batch: Error: model server never became ready. Please validate that your model file or container configuration are valid.

Requisiti dei dati di input

L'input per le richieste batch specifica gli elementi da inviare al modello per l'inferenza. Sono supportati i seguenti formati di input:

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

Dati di partizione

L'inferenza batch utilizza MapReduce per suddividere l'input in ogni replica. Per utilizzare le funzionalità di MapReduce, l'input deve essere partizionabile.

Vertex AI partiziona automaticamente l'input BigQuery, elenco di file e righe JSON.

Vertex AI non partiziona automaticamente i file CSV perché non sono naturalmente adatti alla partizione. Le righe dei file CSV non sono autodescrittive, sono digitate e possono contenere nuove righe. Sconsigliamo l'utilizzo dell'input CSV per le applicazioni sensibili al throughput.

Per l'input TFRecord, assicurati di partizionare manualmente i dati dividendo le istanze in file più piccoli e passando i file al job con un carattere jolly (ad esempio, gs://my-bucket/*.tfrecord). Il numero di file deve essere almeno pari al numero di repliche specificato.

Filtrare e trasformare i dati di input

Puoi filtrare e trasformare l'input batch specificando instanceConfig nella richiesta BatchPredictionJob.

Il filtraggio ti consente di escludere determinati campi presenti nei dati di input dalla richiesta di inferenza o di includere solo un sottoinsieme di campi dei dati di input nella richiesta di inferenza, senza dover eseguire alcuna pre-elaborazione o post-elaborazione personalizzata nel contenitore di inferenza. Ciò è utile quando il file di dati di input contiene colonne aggiuntive di cui il modello non ha bisogno, ad esempio chiavi o dati aggiuntivi.

Trasformazione ti consente di inviare le istanze al contenitore in formato JSON array o object. Per saperne di più, consulta instanceType.

Ad esempio, se la tabella di input contiene quanto segue:

e specifichi i seguenti instanceConfig:

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

Successivamente, le istanze nella richiesta di inferenza vengono inviate come oggetti JSON e la colonna customerId viene esclusa:

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

Tieni presente che specificare quanto segue instanceConfig produrrebbe lo stesso risultato:

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

Per una dimostrazione su come utilizzare i filtri delle funzionalità, consulta il notebook Inferenza batch del modello personalizzato con filtro delle funzionalità.

Richiedere un'inferenza batch

Per le richieste di inferenza batch, puoi utilizzare la console Google Cloud o l'API Vertex AI. A seconda del numero di elementi di input che hai inviato, il completamento di un'attività di inferenza batch può richiedere un po' di tempo.

Quando richiedi un'inferenza batch, il container di inferenza viene eseguito come account di servizio personalizzato fornito dall'utente. Le operazioni di lettura/scrittura, come la lettura delle istanze di inferenza dall'origine dati o la scrittura dei risultati dell'inferenza, vengono eseguite utilizzando l'agente di servizio Vertex AI, che per impostazione predefinita ha accesso a BigQuery e Cloud Storage.

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

Scegli il tipo di macchina e il numero di repliche

Lo scaling orizzontale aumentando il numero di repliche migliora la velocità effettiva in modo più lineare e prevedibile rispetto all'utilizzo di tipi di macchina più grandi.

In generale, ti consigliamo di specificare il tipo di macchina più piccolo possibile per il job e aumentare il numero di repliche.

Per l'efficienza dei costi, ti consigliamo di scegliere il numero di repliche in modo che il job di inferenza batch venga eseguito per almeno 10 minuti. Questo perché ti viene addebitato ilora nodoo di replica, che include i circa 5 minuti necessari per l'avvio di ogni replica. Non è conveniente elaborare per solo pochi secondi e poi spegnersi.

Come indicazione generale, per migliaia di istanze, consigliamo un starting_replica_count di decine. Per milioni di istanze, consigliamo un starting_replica_count di centinaia. Puoi anche utilizzare la seguente formula per stimare il numero di repliche:

N / (T * (60 / Tb))

Dove:

• N: il numero di batch nel job. Ad esempio, 1 milione di istanze / 100 dimensioni batch = 10.000 batch.
• T: il tempo previsto per il job di inferenza batch. Ad esempio, 10 minuti.
• Tb: il tempo in secondi necessario a una replica per elaborare un singolo batch. Ad esempio, 1 secondo per batch su un tipo di macchina con 2 core.

Nel nostro esempio, 10.000 batch / (10 minuti * (60 / 1 s)) viene arrotondato a 17 repliche.

A differenza dell'inferenza online, i job di inferenza batch non vengono scalati automaticamente. Poiché tutti i dati di input sono noti in anticipo, il sistema partiziona i dati in ogni replica all'avvio del job. Il sistema utilizza il parametro starting_replica_count. Il parametro max_replica_count viene ignorato.

Questi consigli sono tutte linee guida approssimative. ma non garantiscono necessariamente una velocità effettiva ottimale per ogni modello. Non forniscono stime esatte dei tempi e dei costi di elaborazione. e non necessariamente acquisiscono i migliori compromessi tra costi e throughput per ogni scenario. Usali come punto di partenza ragionevole e modificali in base alle tue esigenze. Per misurare caratteristiche come il throughput del modello, esegui il notebook Trovare il tipo di macchina ideale.

Per macchine accelerate da GPU o TPU

Segui le linee guida precedenti (che si applicano anche ai modelli solo CPU), con le seguenti considerazioni aggiuntive:

• Potresti aver bisogno di più CPU e GPU (ad esempio per la preelaborazione dei dati).
• I tipi di macchine GPU richiedono più tempo per l'avvio (10 minuti), quindi ti consigliamo di impostare tempi più lunghi (ad esempio, almeno 20 minuti anziché 10 minuti) per il job di inferenza batch, in modo che una parte ragionevole del tempo e dei costi venga spesa per generare inferenze.

Recuperare i risultati dell'inferenza batch

Al termine di un'attività di inferenza batch, l'output dell'inferenza viene archiviato nel bucket Cloud Storage o nella posizione BigQuery che hai specificato nella richiesta.

Esempio di risultato dell'inferenza batch

La cartella di output contiene un insieme di file JSON Lines.

I file sono denominati {gcs_path}/prediction.results-{file_number}-of-{number_of_files_generated}. Il numero di file non è deterministico a causa della natura distribuita dell'inferenza batch.

Ogni riga del file corrisponde a un'istanza dell'input e contiene le seguenti coppie chiave-valore:

• prediction: contiene il valore restituito dal contenitore.
• instance: per un elenco di file, contiene l'URI Cloud Storage. Per tutti gli altri formati di input, contiene il valore inviato al container nel corpo della richiesta HTTP.

Esempio 1

Se la richiesta HTTP contiene:

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

Il container restituisce:

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

Il file di output JSON Lines è:

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

Esempio 2

Se la richiesta HTTP contiene:

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

Il container restituisce:

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

Il file di output JSON Lines è:

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

Utilizzare Explainable AI

Non è consigliabile eseguire le spiegazioni basate sulle caratteristiche su una grande quantità di dati. Questo perché ogni input può potenzialmente generare migliaia di richieste in base all'insieme di possibili valori delle caratteristiche, il che può comportare un aumento massiccio del tempo e dei costi di elaborazione. In generale, un piccolo set di dati è sufficiente per comprendere l'importanza delle funzionalità.

L'inferenza batch non supporta le spiegazioni basate su esempi.

Notebook

Passaggi successivi

• Scopri di più sulle risorse di computing per l'inferenza.